MBeanExporter

java.lang.Object
- org.springframework.jmx.support.MBeanRegistrationSupport
- - org.springframework.jmx.export.MBeanExporter

All Implemented Interfaces:

Aware, BeanClassLoaderAware, BeanFactoryAware, DisposableBean, InitializingBean, SmartInitializingSingleton, MBeanExportOperations

Direct Known Subclasses:

AnnotationMBeanExporter
```
public class MBeanExporter
extends MBeanRegistrationSupport
implements MBeanExportOperations, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, SmartInitializingSingleton, DisposableBean
```
JMX exporter that allows for exposing any Spring-managed bean to a JMX MBeanServer, without the need to define any JMX-specific information in the bean classes.
If a bean implements one of the JMX management interfaces, MBeanExporter can simply register the MBean with the server through its autodetection process.
If a bean does not implement one of the JMX management interfaces, MBeanExporter will create the management information using the supplied MBeanInfoAssembler.
A list of MBeanExporterListeners can be registered via the listeners property, allowing application code to be notified of MBean registration and unregistration events.
This exporter is compatible with MBeans and MXBeans on Java 6 and above.

Since:

1.2

Author:

Rob Harrop, Juergen Hoeller, Rick Evans, Mark Fisher, Stephane Nicoll

See Also:

setBeans(java.util.Map<java.lang.String, java.lang.Object>), setAutodetect(boolean), setAssembler(org.springframework.jmx.export.assembler.MBeanInfoAssembler), setListeners(org.springframework.jmx.export.MBeanExporterListener...), MBeanInfoAssembler, MBeanExporterListener

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static interface`	`MBeanExporter.AutodetectCallback` Internal callback interface for the autodetection process.
`private class`	`MBeanExporter.NotificationPublisherAwareLazyTargetSource` Extension of `LazyInitTargetSource` that will inject a `NotificationPublisher` into the lazy resource as it is created if required.

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`allowEagerInit` Whether to eagerly initialize candidate beans when autodetecting MBeans
`private MBeanInfoAssembler`	`assembler` Stores the MBeanInfoAssembler to use for this exporter
`static int`	`AUTODETECT_ALL` Autodetection mode indicating that all autodetection mechanisms should be used.
`static int`	`AUTODETECT_ASSEMBLER` Autodetection mode indicating that only the `MBeanInfoAssembler` should be able to autodetect beans.
`static int`	`AUTODETECT_MBEAN` Autodetection mode indicating that only valid MBeans should be autodetected.
`static int`	`AUTODETECT_NONE` Autodetection mode indicating that no autodetection should be used.
`private java.lang.Integer`	`autodetectMode` The autodetect mode to use for this MBeanExporter
`private java.lang.ClassLoader`	`beanClassLoader` Stores the ClassLoader to use for generating lazy-init proxies
`private ListableBeanFactory`	`beanFactory` Stores the BeanFactory for use in autodetection process
`private java.util.Map<java.lang.String,java.lang.Object>`	`beans` The beans to be exposed as JMX managed resources, with JMX names as keys
`private static java.lang.String`	`CONSTANT_PREFIX_AUTODETECT` Prefix for the autodetect constants defined in this class
`private static Constants`	`constants` Constants instance for this class
`private boolean`	`ensureUniqueRuntimeObjectNames` Indicates whether Spring should modify generated ObjectNames
`private java.util.Set<java.lang.String>`	`excludedBeans` A set of bean names that should be excluded from autodetection
`private boolean`	`exposeManagedResourceClassLoader` Indicates whether Spring should expose the managed resource ClassLoader in the MBean
`private MBeanExporterListener[]`	`listeners` The MBeanExporterListeners registered with this exporter.
`private static java.lang.String`	`MR_TYPE_OBJECT_REFERENCE` Constant for the JMX `mr_type` "ObjectReference"
`private ObjectNamingStrategy`	`namingStrategy` The strategy to use for creating ObjectNames for an object
`private NotificationListenerBean[]`	`notificationListeners` The NotificationListeners to register for the MBeans registered by this exporter
`private java.util.Map<NotificationListenerBean,javax.management.ObjectName[]>`	`registeredNotificationListeners` Map of actually registered NotificationListeners
`private static java.lang.String`	`WILDCARD` Wildcard used to map a `NotificationListener` to all MBeans registered by the `MBeanExporter`.

Fields inherited from class org.springframework.jmx.support.MBeanRegistrationSupport
logger, REGISTRATION_FAIL_ON_EXISTING, REGISTRATION_IGNORE_EXISTING, REGISTRATION_REPLACE_EXISTING, server

Constructor Summary

Constructors
Constructor and Description

MBeanExporter()

Constructors
Constructor and Description
`MBeanExporter()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected javax.management.DynamicMBean`	`adaptMBeanIfPossible(java.lang.Object bean)` Build an adapted MBean for the given bean instance, if possible.
`void`	`afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
`void`	`afterSingletonsInstantiated()` Kick off bean registration automatically when deployed in an `ApplicationContext`.
`private void`	`autodetect(MBeanExporter.AutodetectCallback callback)` Performs the actual autodetection process, delegating to an `AutodetectCallback` instance to vote on the inclusion of a given bean.
`private void`	`autodetectBeans(AutodetectCapableMBeanInfoAssembler assembler)` Invoked when using an `AutodetectCapableMBeanInfoAssembler`.
`private void`	`autodetectMBeans()` Attempts to detect any beans defined in the `ApplicationContext` that are valid MBeans and registers them automatically with the `MBeanServer`.
`protected javax.management.modelmbean.ModelMBean`	`createAndConfigureMBean(java.lang.Object managedResource, java.lang.String beanKey)` Creates an MBean that is configured with the appropriate management interface for the supplied managed resource.
`protected javax.management.modelmbean.ModelMBean`	`createModelMBean()` Create an instance of a class that implements `ModelMBean`.
`void`	`destroy()` Unregisters all beans that this exported has exposed via JMX when the enclosing `ApplicationContext` is destroyed.
`private javax.management.modelmbean.ModelMBeanInfo`	`getMBeanInfo(java.lang.Object managedBean, java.lang.String beanKey)` Gets the `ModelMBeanInfo` for the bean with the supplied key and of the supplied type.
`protected javax.management.ObjectName`	`getObjectName(java.lang.Object bean, java.lang.String beanKey)` Retrieve the `ObjectName` for a bean.
`private void`	`injectNotificationPublisherIfNecessary(java.lang.Object managedResource, javax.management.modelmbean.ModelMBean modelMBean, javax.management.ObjectName objectName)` If the supplied managed resource implements the `NotificationPublisherAware` an instance of `NotificationPublisher` is injected.
`private boolean`	`isBeanDefinitionAbstract(ListableBeanFactory beanFactory, java.lang.String beanName)` Return whether the specified bean definition should be considered as abstract.
`protected boolean`	`isBeanDefinitionLazyInit(ListableBeanFactory beanFactory, java.lang.String beanName)` Return whether the specified bean definition should be considered as lazy-init.
`private boolean`	`isExcluded(java.lang.String beanName)` Indicates whether or not a particular bean name is present in the excluded beans list.
`protected boolean`	`isMBean(java.lang.Class<?> beanClass)` Determine whether the given bean class qualifies as an MBean as-is.
`private void`	`notifyListenersOfRegistration(javax.management.ObjectName objectName)` Notifies all registered `MBeanExporterListeners` of the registration of the MBean identified by the supplied `ObjectName`.
`private void`	`notifyListenersOfUnregistration(javax.management.ObjectName objectName)` Notifies all registered `MBeanExporterListeners` of the unregistration of the MBean identified by the supplied `ObjectName`.
`protected void`	`onRegister(javax.management.ObjectName objectName)` Called when an MBean is registered.
`protected void`	`onUnregister(javax.management.ObjectName objectName)` Called when an MBean is unregistered.
`private javax.management.ObjectName`	`registerBeanInstance(java.lang.Object bean, java.lang.String beanKey)` Registers an existing MBean or an MBean adapter for a plain bean with the `MBeanServer`.
`protected javax.management.ObjectName`	`registerBeanNameOrInstance(java.lang.Object mapValue, java.lang.String beanKey)` Registers an individual bean with the `MBeanServer`.
`protected void`	`registerBeans()` Registers the defined beans with the `MBeanServer`.
`private javax.management.ObjectName`	`registerLazyInit(java.lang.String beanName, java.lang.String beanKey)` Registers beans that are configured for lazy initialization with the `MBeanServer` indirectly through a proxy.
`javax.management.ObjectName`	`registerManagedResource(java.lang.Object managedResource)` Register the supplied resource with JMX.
`void`	`registerManagedResource(java.lang.Object managedResource, javax.management.ObjectName objectName)` Register the supplied resource with JMX.
`private void`	`registerNotificationListeners()` Register the configured `NotificationListeners` with the `MBeanServer`.
`private void`	`replaceNotificationListenerBeanNameKeysIfNecessary(java.lang.String beanName, javax.management.ObjectName objectName)` Replaces any bean names used as keys in the `NotificationListener` mappings with their corresponding `ObjectName` values.
`void`	`setAllowEagerInit(boolean allowEagerInit)` Specify whether to allow eager initialization of candidate beans when autodetecting MBeans in the Spring application context.
`void`	`setAssembler(MBeanInfoAssembler assembler)` Set the implementation of the `MBeanInfoAssembler` interface to use for this exporter.
`void`	`setAutodetect(boolean autodetect)` Set whether to autodetect MBeans in the bean factory that this exporter runs in.
`void`	`setAutodetectMode(int autodetectMode)` Set the autodetection mode to use.
`void`	`setAutodetectModeName(java.lang.String constantName)` Set the autodetection mode to use by name.
`void`	`setBeanClassLoader(java.lang.ClassLoader classLoader)` Callback that supplies the bean `class loader` to a bean instance.
`void`	`setBeanFactory(BeanFactory beanFactory)` This callback is only required for resolution of bean names in the `"beans"` `Map` and for autodetection of MBeans (in the latter case, a `ListableBeanFactory` is required).
`void`	`setBeans(java.util.Map<java.lang.String,java.lang.Object> beans)` Supply a `Map` of beans to be registered with the JMX `MBeanServer`.
`void`	`setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)` Indicates whether Spring should ensure that `ObjectNames` generated by the configured `ObjectNamingStrategy` for runtime-registered MBeans (`registerManagedResource(java.lang.Object)`) should get modified: to ensure uniqueness for every instance of a managed `Class`.
`void`	`setExcludedBeans(java.lang.String... excludedBeans)` Set the list of names for beans that should be excluded from autodetection.
`void`	`setExposeManagedResourceClassLoader(boolean exposeManagedResourceClassLoader)` Indicates whether or not the managed resource should be exposed on the `thread context ClassLoader` before allowing any invocations on the MBean to occur.
`void`	`setListeners(MBeanExporterListener... listeners)` Set the `MBeanExporterListener`s that should be notified of MBean registration and unregistration events.
`void`	`setNamingStrategy(ObjectNamingStrategy namingStrategy)` Set the implementation of the `ObjectNamingStrategy` interface to use for this exporter.
`void`	`setNotificationListenerMappings(java.util.Map<?,? extends javax.management.NotificationListener> listeners)` Set the `NotificationListeners` to register with the `MBeanServer`.
`void`	`setNotificationListeners(NotificationListenerBean... notificationListeners)` Set the `NotificationListenerBeans` containing the `NotificationListeners` that will be registered with the `MBeanServer`.
`void`	`unregisterManagedResource(javax.management.ObjectName objectName)` Remove the specified MBean from the underlying MBeanServer registry.
`private void`	`unregisterNotificationListeners()` Unregister the configured `NotificationListeners` from the `MBeanServer`.

Methods inherited from class org.springframework.jmx.support.MBeanRegistrationSupport
doRegister, doUnregister, getRegisteredObjectNames, getServer, onRegister, setRegistrationBehavior, setRegistrationBehaviorName, setRegistrationPolicy, setServer, unregisterBeans

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - AUTODETECT_NONE
```
public static final int AUTODETECT_NONE
```
    Autodetection mode indicating that no autodetection should be used.
    
    See Also:
    
    Constant Field Values
  - AUTODETECT_MBEAN
```
public static final int AUTODETECT_MBEAN
```
    Autodetection mode indicating that only valid MBeans should be autodetected.
    
    See Also:
    
    Constant Field Values
  - AUTODETECT_ASSEMBLER
```
public static final int AUTODETECT_ASSEMBLER
```
    Autodetection mode indicating that only the MBeanInfoAssembler should be able to autodetect beans.
    
    See Also:
    
    Constant Field Values
  - AUTODETECT_ALL
```
public static final int AUTODETECT_ALL
```
    Autodetection mode indicating that all autodetection mechanisms should be used.
    
    See Also:
    
    Constant Field Values
  - WILDCARD
```
private static final java.lang.String WILDCARD
```
    Wildcard used to map a NotificationListener to all MBeans registered by the MBeanExporter.
    
    See Also:
    
    Constant Field Values
  - MR_TYPE_OBJECT_REFERENCE
```
private static final java.lang.String MR_TYPE_OBJECT_REFERENCE
```
    Constant for the JMX mr_type "ObjectReference"
    
    See Also:
    
    Constant Field Values
  - CONSTANT_PREFIX_AUTODETECT
```
private static final java.lang.String CONSTANT_PREFIX_AUTODETECT
```
    Prefix for the autodetect constants defined in this class
    
    See Also:
    
    Constant Field Values
  - constants
```
private static final Constants constants
```
    Constants instance for this class
  - beans
```
private java.util.Map<java.lang.String,java.lang.Object> beans
```
    The beans to be exposed as JMX managed resources, with JMX names as keys
  - autodetectMode
```
private java.lang.Integer autodetectMode
```
    The autodetect mode to use for this MBeanExporter
  - allowEagerInit
```
private boolean allowEagerInit
```
    Whether to eagerly initialize candidate beans when autodetecting MBeans
  - assembler
```
private MBeanInfoAssembler assembler
```
    Stores the MBeanInfoAssembler to use for this exporter
  - namingStrategy
```
private ObjectNamingStrategy namingStrategy
```
    The strategy to use for creating ObjectNames for an object
  - ensureUniqueRuntimeObjectNames
```
private boolean ensureUniqueRuntimeObjectNames
```
    Indicates whether Spring should modify generated ObjectNames
  - exposeManagedResourceClassLoader
```
private boolean exposeManagedResourceClassLoader
```
    Indicates whether Spring should expose the managed resource ClassLoader in the MBean
  - excludedBeans
```
private java.util.Set<java.lang.String> excludedBeans
```
    A set of bean names that should be excluded from autodetection
  - listeners
```
private MBeanExporterListener[] listeners
```
    The MBeanExporterListeners registered with this exporter.
  - notificationListeners
```
private NotificationListenerBean[] notificationListeners
```
    The NotificationListeners to register for the MBeans registered by this exporter
  - registeredNotificationListeners
```
private final java.util.Map<NotificationListenerBean,javax.management.ObjectName[]> registeredNotificationListeners
```
    Map of actually registered NotificationListeners
  - beanClassLoader
```
private java.lang.ClassLoader beanClassLoader
```
    Stores the ClassLoader to use for generating lazy-init proxies
  - beanFactory
```
private ListableBeanFactory beanFactory
```
    Stores the BeanFactory for use in autodetection process
- Constructor Detail
  - MBeanExporter
```
public MBeanExporter()
```
- Method Detail
  - setBeans
```
public void setBeans(java.util.Map<java.lang.String,java.lang.Object> beans)
```
    Supply a Map of beans to be registered with the JMX MBeanServer.
    The String keys are the basis for the creation of JMX object names. By default, a JMX ObjectName will be created straight from the given key. This can be customized through specifying a custom NamingStrategy.
    Both bean instances and bean names are allowed as values. Bean instances are typically linked in through bean references. Bean names will be resolved as beans in the current factory, respecting lazy-init markers (that is, not triggering initialization of such beans).
    
    Parameters:
    
    beans - Map with JMX names as keys and bean instances or bean names as values
    
    See Also:
    
    setNamingStrategy(org.springframework.jmx.export.naming.ObjectNamingStrategy), KeyNamingStrategy, ObjectName.ObjectName(String)
  - setAutodetect
```
public void setAutodetect(boolean autodetect)
```
    Set whether to autodetect MBeans in the bean factory that this exporter runs in. Will also ask an AutodetectCapableMBeanInfoAssembler if available.
    This feature is turned off by default. Explicitly specify true here to enable autodetection.
    
    See Also:
    
    setAssembler(org.springframework.jmx.export.assembler.MBeanInfoAssembler), AutodetectCapableMBeanInfoAssembler, isMBean(java.lang.Class<?>)
  - setAutodetectMode
```
public void setAutodetectMode(int autodetectMode)
```
    Set the autodetection mode to use.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the supplied value is not one of the AUTODETECT_ constants
    
    See Also:
    
    setAutodetectModeName(String), AUTODETECT_ALL, AUTODETECT_ASSEMBLER, AUTODETECT_MBEAN, AUTODETECT_NONE
  - setAutodetectModeName
```
public void setAutodetectModeName(java.lang.String constantName)
```
    Set the autodetection mode to use by name.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the supplied value is not resolvable to one of the AUTODETECT_ constants or is null
    
    See Also:
    
    setAutodetectMode(int), AUTODETECT_ALL, AUTODETECT_ASSEMBLER, AUTODETECT_MBEAN, AUTODETECT_NONE
  - setAllowEagerInit
```
public void setAllowEagerInit(boolean allowEagerInit)
```
    Specify whether to allow eager initialization of candidate beans when autodetecting MBeans in the Spring application context.
    Default is "false", respecting lazy-init flags on bean definitions. Switch this to "true" in order to search lazy-init beans as well, including FactoryBean-produced objects that haven't been initialized yet.
  - setAssembler
```
public void setAssembler(MBeanInfoAssembler assembler)
```
    Set the implementation of the MBeanInfoAssembler interface to use for this exporter. Default is a SimpleReflectiveMBeanInfoAssembler.
    The passed-in assembler can optionally implement the AutodetectCapableMBeanInfoAssembler interface, which enables it to participate in the exporter's MBean autodetection process.
    
    See Also:
    
    SimpleReflectiveMBeanInfoAssembler, AutodetectCapableMBeanInfoAssembler, MetadataMBeanInfoAssembler, setAutodetect(boolean)
  - setNamingStrategy
```
public void setNamingStrategy(ObjectNamingStrategy namingStrategy)
```
    Set the implementation of the ObjectNamingStrategy interface to use for this exporter. Default is a KeyNamingStrategy.
    
    See Also:
    
    KeyNamingStrategy, MetadataNamingStrategy
  - setEnsureUniqueRuntimeObjectNames
```
public void setEnsureUniqueRuntimeObjectNames(boolean ensureUniqueRuntimeObjectNames)
```
    Indicates whether Spring should ensure that ObjectNames generated by the configured ObjectNamingStrategy for runtime-registered MBeans (registerManagedResource(java.lang.Object)) should get modified: to ensure uniqueness for every instance of a managed Class.
    The default value is true.
    
    See Also:
    
    registerManagedResource(java.lang.Object), JmxUtils.appendIdentityToObjectName(javax.management.ObjectName, Object)
  - setExposeManagedResourceClassLoader
```
public void setExposeManagedResourceClassLoader(boolean exposeManagedResourceClassLoader)
```
    Indicates whether or not the managed resource should be exposed on the thread context ClassLoader before allowing any invocations on the MBean to occur.
    The default value is true, exposing a SpringModelMBean which performs thread context ClassLoader management. Switch this flag off to expose a standard JMX RequiredModelMBean.
  - setExcludedBeans
```
public void setExcludedBeans(java.lang.String... excludedBeans)
```
    Set the list of names for beans that should be excluded from autodetection.
  - setListeners
```
public void setListeners(MBeanExporterListener... listeners)
```
    Set the MBeanExporterListeners that should be notified of MBean registration and unregistration events.
    
    See Also:
    
    MBeanExporterListener
  - setNotificationListeners
```
public void setNotificationListeners(NotificationListenerBean... notificationListeners)
```
    Set the NotificationListenerBeans containing the NotificationListeners that will be registered with the MBeanServer.
    
    See Also:
    
    setNotificationListenerMappings(java.util.Map), NotificationListenerBean
  - setNotificationListenerMappings
```
public void setNotificationListenerMappings(java.util.Map<?,? extends javax.management.NotificationListener> listeners)
```
    Set the NotificationListeners to register with the MBeanServer.
    The key of each entry in the Map is a String representation of the ObjectName or the bean name of the MBean the listener should be registered for. Specifying an asterisk (*) for a key will cause the listener to be associated with all MBeans registered by this class at startup time.
    The value of each entry is the NotificationListener to register. For more advanced options such as registering NotificationFilters and handback objects see setNotificationListeners(NotificationListenerBean[]).
  - setBeanClassLoader
```
public void setBeanClassLoader(java.lang.ClassLoader classLoader)
```
    Description copied from interface: BeanClassLoaderAware
    
    Callback that supplies the bean class loader to a bean instance.
    Invoked after the population of normal bean properties but before an initialization callback such as InitializingBean's InitializingBean.afterPropertiesSet() method or a custom init-method.
    
    Specified by:
    
    setBeanClassLoader in interface BeanClassLoaderAware
    
    Parameters:
    
    classLoader - the owning class loader; may be null in which case a default ClassLoader must be used, for example the ClassLoader obtained via ClassUtils.getDefaultClassLoader()
  - setBeanFactory
```
public void setBeanFactory(BeanFactory beanFactory)
```
    This callback is only required for resolution of bean names in the "beans" Map and for autodetection of MBeans (in the latter case, a ListableBeanFactory is required).
    
    Specified by:
    
    setBeanFactory in interface BeanFactoryAware
    
    Parameters:
    
    beanFactory - owning BeanFactory (never null). The bean can immediately call methods on the factory.
    
    See Also:
    
    setBeans(java.util.Map<java.lang.String, java.lang.Object>), setAutodetect(boolean)
  - afterPropertiesSet
```
public void afterPropertiesSet()
```
    Description copied from interface: InitializingBean
    
    Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
    This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.
    
    Specified by:
    
    afterPropertiesSet in interface InitializingBean
  - afterSingletonsInstantiated
```
public void afterSingletonsInstantiated()
```
    Kick off bean registration automatically when deployed in an ApplicationContext.
    
    Specified by:
    
    afterSingletonsInstantiated in interface SmartInitializingSingleton
    
    See Also:
    
    registerBeans()
  - destroy
```
public void destroy()
```
    Unregisters all beans that this exported has exposed via JMX when the enclosing ApplicationContext is destroyed.
    
    Specified by:
    
    destroy in interface DisposableBean
  - registerManagedResource
```
public javax.management.ObjectName registerManagedResource(java.lang.Object managedResource)
                                                    throws MBeanExportException
```
    Description copied from interface: MBeanExportOperations
    
    Register the supplied resource with JMX. If the resource is not a valid MBean already, Spring will generate a management interface for it. The exact interface generated will depend on the implementation and its configuration. This call also generates an ObjectName for the managed resource and returns this to the caller.
    
    Specified by:
    
    registerManagedResource in interface MBeanExportOperations
    
    Parameters:
    
    managedResource - the resource to expose via JMX
    
    Returns:
    
    the ObjectName under which the resource was exposed
    
    Throws:
    
    MBeanExportException - if Spring is unable to generate an ObjectName or register the MBean
  - registerManagedResource
```
public void registerManagedResource(java.lang.Object managedResource,
                                    javax.management.ObjectName objectName)
                             throws MBeanExportException
```
    Description copied from interface: MBeanExportOperations
    
    Register the supplied resource with JMX. If the resource is not a valid MBean already, Spring will generate a management interface for it. The exact interface generated will depend on the implementation and its configuration.
    
    Specified by:
    
    registerManagedResource in interface MBeanExportOperations
    
    Parameters:
    
    managedResource - the resource to expose via JMX
    
    objectName - the ObjectName under which to expose the resource
    
    Throws:
    
    MBeanExportException - if Spring is unable to register the MBean
  - unregisterManagedResource
```
public void unregisterManagedResource(javax.management.ObjectName objectName)
```
    Description copied from interface: MBeanExportOperations
    
    Remove the specified MBean from the underlying MBeanServer registry.
    
    Specified by:
    
    unregisterManagedResource in interface MBeanExportOperations
    
    Parameters:
    
    objectName - the ObjectName of the resource to remove
  - registerBeans
```
protected void registerBeans()
```
    Registers the defined beans with the MBeanServer.
    Each bean is exposed to the MBeanServer via a ModelMBean. The actual implemetation of the ModelMBean interface used depends on the implementation of the ModelMBeanProvider interface that is configured. By default the RequiredModelMBean class that is supplied with all JMX implementations is used.
    The management interface produced for each bean is dependent on the MBeanInfoAssembler implementation being used. The ObjectName given to each bean is dependent on the implementation of the ObjectNamingStrategy interface being used.
  - isBeanDefinitionLazyInit
```
protected boolean isBeanDefinitionLazyInit(ListableBeanFactory beanFactory,
                                           java.lang.String beanName)
```
    Return whether the specified bean definition should be considered as lazy-init.
    
    Parameters:
    
    beanFactory - the bean factory that is supposed to contain the bean definition
    
    beanName - the name of the bean to check
    
    See Also:
    
    ConfigurableListableBeanFactory.getBeanDefinition(java.lang.String), BeanDefinition.isLazyInit()
  - registerBeanNameOrInstance
```
protected javax.management.ObjectName registerBeanNameOrInstance(java.lang.Object mapValue,
                                                                 java.lang.String beanKey)
                                                          throws MBeanExportException
```
    Registers an individual bean with the MBeanServer.
    This method is responsible for deciding how a bean should be exposed to the MBeanServer. Specifically, if the supplied mapValue is the name of a bean that is configured for lazy initialization, then a proxy to the resource is registered with the MBeanServer so that the the lazy load behavior is honored. If the bean is already an MBean then it will be registered directly with the MBeanServer without any intervention. For all other beans or bean names, the resource itself is registered with the MBeanServer directly.
    
    Parameters:
    
    mapValue - the value configured for this bean in the beans map; may be either the String name of a bean, or the bean itself
    
    beanKey - the key associated with this bean in the beans map
    
    Returns:
    
    the ObjectName under which the resource was registered
    
    Throws:
    
    MBeanExportException - if the export failed
    
    See Also:
    
    setBeans(java.util.Map<java.lang.String, java.lang.Object>), registerBeanInstance(java.lang.Object, java.lang.String), registerLazyInit(java.lang.String, java.lang.String)
  - replaceNotificationListenerBeanNameKeysIfNecessary
```
private void replaceNotificationListenerBeanNameKeysIfNecessary(java.lang.String beanName,
                                                                javax.management.ObjectName objectName)
```
    Replaces any bean names used as keys in the NotificationListener mappings with their corresponding ObjectName values.
    
    Parameters:
    
    beanName - the name of the bean to be registered
    
    objectName - the ObjectName under which the bean will be registered with the MBeanServer
  - registerBeanInstance
```
private javax.management.ObjectName registerBeanInstance(java.lang.Object bean,
                                                         java.lang.String beanKey)
                                                  throws javax.management.JMException
```
    Registers an existing MBean or an MBean adapter for a plain bean with the MBeanServer.
    
    Parameters:
    
    bean - the bean to register, either an MBean or a plain bean
    
    beanKey - the key associated with this bean in the beans map
    
    Returns:
    
    the ObjectName under which the bean was registered with the MBeanServer
    
    Throws:
    
    javax.management.JMException
  - registerLazyInit
```
private javax.management.ObjectName registerLazyInit(java.lang.String beanName,
                                                     java.lang.String beanKey)
                                              throws javax.management.JMException
```
    Registers beans that are configured for lazy initialization with the MBeanServer indirectly through a proxy.
    
    Parameters:
    
    beanName - the name of the bean in the BeanFactory
    
    beanKey - the key associated with this bean in the beans map
    
    Returns:
    
    the ObjectName under which the bean was registered with the MBeanServer
    
    Throws:
    
    javax.management.JMException
  - getObjectName
```
protected javax.management.ObjectName getObjectName(java.lang.Object bean,
                                                    java.lang.String beanKey)
                                             throws javax.management.MalformedObjectNameException
```
    Retrieve the ObjectName for a bean.
    If the bean implements the SelfNaming interface, then the ObjectName will be retrieved using SelfNaming.getObjectName(). Otherwise, the configured ObjectNamingStrategy is used.
    
    Parameters:
    
    bean - the name of the bean in the BeanFactory
    
    beanKey - the key associated with the bean in the beans map
    
    Returns:
    
    the ObjectName for the supplied bean
    
    Throws:
    
    javax.management.MalformedObjectNameException - if the retrieved ObjectName is malformed
  - isMBean
```
protected boolean isMBean(java.lang.Class<?> beanClass)
```
    Determine whether the given bean class qualifies as an MBean as-is.
    The default implementation delegates to JmxUtils.isMBean(java.lang.Class<?>), which checks for DynamicMBean classes as well as classes with corresponding "*MBean" interface (Standard MBeans) or corresponding "*MXBean" interface (Java 6 MXBeans).
    
    Parameters:
    
    beanClass - the bean class to analyze
    
    Returns:
    
    whether the class qualifies as an MBean
    
    See Also:
    
    JmxUtils.isMBean(Class)
  - adaptMBeanIfPossible
```
protected javax.management.DynamicMBean adaptMBeanIfPossible(java.lang.Object bean)
                                                      throws javax.management.JMException
```
    Build an adapted MBean for the given bean instance, if possible.
    The default implementation builds a JMX 1.2 StandardMBean for the target's MBean/MXBean interface in case of an AOP proxy, delegating the interface's management operations to the proxy.
    
    Parameters:
    
    bean - the original bean instance
    
    Returns:
    
    the adapted MBean, or null if not possible
    
    Throws:
    
    javax.management.JMException
  - createAndConfigureMBean
```
protected javax.management.modelmbean.ModelMBean createAndConfigureMBean(java.lang.Object managedResource,
                                                                         java.lang.String beanKey)
                                                                  throws MBeanExportException
```
    Creates an MBean that is configured with the appropriate management interface for the supplied managed resource.
    
    Parameters:
    
    managedResource - the resource that is to be exported as an MBean
    
    beanKey - the key associated with the managed bean
    
    Throws:
    
    MBeanExportException
    
    See Also:
    
    createModelMBean(), getMBeanInfo(Object, String)
  - createModelMBean
```
protected javax.management.modelmbean.ModelMBean createModelMBean()
                                                           throws javax.management.MBeanException
```
    Create an instance of a class that implements ModelMBean.
    This method is called to obtain a ModelMBean instance to use when registering a bean. This method is called once per bean during the registration phase and must return a new instance of ModelMBean
    
    Returns:
    
    a new instance of a class that implements ModelMBean
    
    Throws:
    
    javax.management.MBeanException - if creation of the ModelMBean failed
  - getMBeanInfo
```
private javax.management.modelmbean.ModelMBeanInfo getMBeanInfo(java.lang.Object managedBean,
                                                                java.lang.String beanKey)
                                                         throws javax.management.JMException
```
    Gets the ModelMBeanInfo for the bean with the supplied key and of the supplied type.
    
    Throws:
    
    javax.management.JMException
  - autodetectBeans
```
private void autodetectBeans(AutodetectCapableMBeanInfoAssembler assembler)
```
    Invoked when using an AutodetectCapableMBeanInfoAssembler. Gives the assembler the opportunity to add additional beans from the BeanFactory to the list of beans to be exposed via JMX.
    This implementation prevents a bean from being added to the list automatically if it has already been added manually, and it prevents certain internal classes from being registered automatically.
  - autodetectMBeans
```
private void autodetectMBeans()
```
    Attempts to detect any beans defined in the ApplicationContext that are valid MBeans and registers them automatically with the MBeanServer.
  - autodetect
```
private void autodetect(MBeanExporter.AutodetectCallback callback)
```
    Performs the actual autodetection process, delegating to an AutodetectCallback instance to vote on the inclusion of a given bean.
    
    Parameters:
    
    callback - the AutodetectCallback to use when deciding whether to include a bean or not
  - isExcluded
```
private boolean isExcluded(java.lang.String beanName)
```
    Indicates whether or not a particular bean name is present in the excluded beans list.
  - isBeanDefinitionAbstract
```
private boolean isBeanDefinitionAbstract(ListableBeanFactory beanFactory,
                                         java.lang.String beanName)
```
    Return whether the specified bean definition should be considered as abstract.
  - injectNotificationPublisherIfNecessary
```
private void injectNotificationPublisherIfNecessary(java.lang.Object managedResource,
                                                    javax.management.modelmbean.ModelMBean modelMBean,
                                                    javax.management.ObjectName objectName)
```
    If the supplied managed resource implements the NotificationPublisherAware an instance of NotificationPublisher is injected.
  - registerNotificationListeners
```
private void registerNotificationListeners()
                                    throws MBeanExportException
```
    Register the configured NotificationListeners with the MBeanServer.
    
    Throws:
    
    MBeanExportException
  - unregisterNotificationListeners
```
private void unregisterNotificationListeners()
```
    Unregister the configured NotificationListeners from the MBeanServer.
  - onRegister
```
protected void onRegister(javax.management.ObjectName objectName)
```
    Called when an MBean is registered. Notifies all registered MBeanExporterListeners of the registration event.
    Please note that if an MBeanExporterListener throws a (runtime) exception when notified, this will essentially interrupt the notification process and any remaining listeners that have yet to be notified will not (obviously) receive the MBeanExporterListener.mbeanRegistered(javax.management.ObjectName) callback.
    
    Overrides:
    
    onRegister in class MBeanRegistrationSupport
    
    Parameters:
    
    objectName - the ObjectName of the registered MBean
  - onUnregister
```
protected void onUnregister(javax.management.ObjectName objectName)
```
    Called when an MBean is unregistered. Notifies all registered MBeanExporterListeners of the unregistration event.
    Please note that if an MBeanExporterListener throws a (runtime) exception when notified, this will essentially interrupt the notification process and any remaining listeners that have yet to be notified will not (obviously) receive the MBeanExporterListener.mbeanUnregistered(javax.management.ObjectName) callback.
    
    Overrides:
    
    onUnregister in class MBeanRegistrationSupport
    
    Parameters:
    
    objectName - the ObjectName of the unregistered MBean
  - notifyListenersOfRegistration
```
private void notifyListenersOfRegistration(javax.management.ObjectName objectName)
```
    Notifies all registered MBeanExporterListeners of the registration of the MBean identified by the supplied ObjectName.
  - notifyListenersOfUnregistration
```
private void notifyListenersOfUnregistration(javax.management.ObjectName objectName)
```
    Notifies all registered MBeanExporterListeners of the unregistration of the MBean identified by the supplied ObjectName.

Class MBeanExporter

Nested Class Summary

Field Summary

Fields inherited from class org.springframework.jmx.support.MBeanRegistrationSupport

Constructor Summary

Method Summary

Methods inherited from class org.springframework.jmx.support.MBeanRegistrationSupport

Methods inherited from class java.lang.Object

Field Detail

AUTODETECT_NONE

AUTODETECT_MBEAN

AUTODETECT_ASSEMBLER

AUTODETECT_ALL

WILDCARD

MR_TYPE_OBJECT_REFERENCE

CONSTANT_PREFIX_AUTODETECT

constants

beans

autodetectMode

allowEagerInit

assembler

namingStrategy

ensureUniqueRuntimeObjectNames

exposeManagedResourceClassLoader

excludedBeans

listeners

notificationListeners

registeredNotificationListeners

beanClassLoader

beanFactory

Constructor Detail

MBeanExporter

Method Detail

setBeans

setAutodetect

setAutodetectMode

setAutodetectModeName

setAllowEagerInit

setAssembler

setNamingStrategy

setEnsureUniqueRuntimeObjectNames

setExposeManagedResourceClassLoader

setExcludedBeans

setListeners

setNotificationListeners

setNotificationListenerMappings

setBeanClassLoader

setBeanFactory

afterPropertiesSet

afterSingletonsInstantiated

destroy

registerManagedResource

registerManagedResource

unregisterManagedResource

registerBeans

isBeanDefinitionLazyInit

registerBeanNameOrInstance

replaceNotificationListenerBeanNameKeysIfNecessary

registerBeanInstance

registerLazyInit

getObjectName

isMBean

adaptMBeanIfPossible

createAndConfigureMBean

createModelMBean

getMBeanInfo

autodetectBeans

autodetectMBeans

autodetect

isExcluded

isBeanDefinitionAbstract

injectNotificationPublisherIfNecessary

registerNotificationListeners

unregisterNotificationListeners

onRegister

onUnregister

notifyListenersOfRegistration

notifyListenersOfUnregistration